YES 1.7870000000000001
H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:
↳ HASKELL
↳ LR
mainModule List
| ((transpose :: [[a]] -> [[a]]) :: [[a]] -> [[a]]) |
module List where
| import qualified Maybe import qualified Prelude
|
| transpose :: [[a]] -> [[a]]
transpose | [] | = | [] |
transpose | ([] : xss) | = | transpose xss |
transpose | ((x : xs) : xss) | = | (x : concatMap (\vv3 ->
case | vv3 of |
| h : t | -> | h : [] |
| _ | -> | [] |
) xss) : transpose (xs : concatMap (\vv4 ->
case | vv4 of |
| h : t | -> | t : [] |
| _ | -> | [] |
) xss) |
|
module Maybe where
| import qualified List import qualified Prelude
|
Lambda Reductions:
The following Lambda expression
\vv3→
case | vv3 of |
| h : t | → h : [] |
| _ | → [] |
is transformed to
transpose0 | vv3 | =
case | vv3 of | | h : t | → h : [] |
| _ | → [] |
|
The following Lambda expression
\vv4→
case | vv4 of |
| h : t | → t : [] |
| _ | → [] |
is transformed to
transpose1 | vv4 | =
case | vv4 of | | h : t | → t : [] |
| _ | → [] |
|
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
mainModule List
| ((transpose :: [[a]] -> [[a]]) :: [[a]] -> [[a]]) |
module List where
| import qualified Maybe import qualified Prelude
|
| transpose :: [[a]] -> [[a]]
transpose | [] | = | [] |
transpose | ([] : xss) | = | transpose xss |
transpose | ((x : xs) : xss) | = | (x : concatMap transpose0 xss) : transpose (xs : concatMap transpose1 xss) |
|
|
transpose0 | vv3 | = |
case | vv3 of |
| h : t | -> | h : [] |
| _ | -> | [] |
|
|
|
transpose1 | vv4 | = |
case | vv4 of |
| h : t | -> | t : [] |
| _ | -> | [] |
|
|
module Maybe where
| import qualified List import qualified Prelude
|
Case Reductions:
The following Case expression
case | vv3 of |
| h : t | → h : [] |
| _ | → [] |
is transformed to
transpose00 | (h : t) | = h : [] |
transpose00 | _ | = [] |
The following Case expression
case | vv4 of |
| h : t | → t : [] |
| _ | → [] |
is transformed to
transpose10 | (h : t) | = t : [] |
transpose10 | _ | = [] |
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
mainModule List
| ((transpose :: [[a]] -> [[a]]) :: [[a]] -> [[a]]) |
module List where
| import qualified Maybe import qualified Prelude
|
| transpose :: [[a]] -> [[a]]
transpose | [] | = | [] |
transpose | ([] : xss) | = | transpose xss |
transpose | ((x : xs) : xss) | = | (x : concatMap transpose0 xss) : transpose (xs : concatMap transpose1 xss) |
|
|
transpose0 | vv3 | = | transpose00 vv3 |
|
|
transpose00 | (h : t) | = | h : [] |
transpose00 | _ | = | [] |
|
|
transpose1 | vv4 | = | transpose10 vv4 |
|
|
transpose10 | (h : t) | = | t : [] |
transpose10 | _ | = | [] |
|
module Maybe where
| import qualified List import qualified Prelude
|
Replaced joker patterns by fresh variables and removed binding patterns.
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
mainModule List
| ((transpose :: [[a]] -> [[a]]) :: [[a]] -> [[a]]) |
module List where
| import qualified Maybe import qualified Prelude
|
| transpose :: [[a]] -> [[a]]
transpose | [] | = | [] |
transpose | ([] : xss) | = | transpose xss |
transpose | ((x : xs) : xss) | = | (x : concatMap transpose0 xss) : transpose (xs : concatMap transpose1 xss) |
|
|
transpose0 | vv3 | = | transpose00 vv3 |
|
|
transpose00 | (h : t) | = | h : [] |
transpose00 | vx | = | [] |
|
|
transpose1 | vv4 | = | transpose10 vv4 |
|
|
transpose10 | (h : t) | = | t : [] |
transpose10 | vw | = | [] |
|
module Maybe where
| import qualified List import qualified Prelude
|
Cond Reductions:
The following Function with conditions
is transformed to
undefined0 | True | = undefined |
undefined1 | | = undefined0 False |
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
↳ HASKELL
↳ Narrow
mainModule List
| (transpose :: [[a]] -> [[a]]) |
module List where
| import qualified Maybe import qualified Prelude
|
| transpose :: [[a]] -> [[a]]
transpose | [] | = | [] |
transpose | ([] : xss) | = | transpose xss |
transpose | ((x : xs) : xss) | = | (x : concatMap transpose0 xss) : transpose (xs : concatMap transpose1 xss) |
|
|
transpose0 | vv3 | = | transpose00 vv3 |
|
|
transpose00 | (h : t) | = | h : [] |
transpose00 | vx | = | [] |
|
|
transpose1 | vv4 | = | transpose10 vv4 |
|
|
transpose10 | (h : t) | = | t : [] |
transpose10 | vw | = | [] |
|
module Maybe where
| import qualified List import qualified Prelude
|
Haskell To QDPs
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
↳ HASKELL
↳ Narrow
↳ AND
↳ QDP
↳ QDPSizeChangeProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
new_foldr(:(wu310, wu311), ba) → new_foldr(wu311, ba)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs:
- new_foldr(:(wu310, wu311), ba) → new_foldr(wu311, ba)
The graph contains the following edges 1 > 1, 2 >= 2
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
↳ HASKELL
↳ Narrow
↳ AND
↳ QDP
↳ QDP
↳ QDPSizeChangeProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
new_foldr0(:(wu310, wu311), ba) → new_foldr0(wu311, ba)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs:
- new_foldr0(:(wu310, wu311), ba) → new_foldr0(wu311, ba)
The graph contains the following edges 1 > 1, 2 >= 2
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
↳ HASKELL
↳ Narrow
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDPOrderProof
Q DP problem:
The TRS P consists of the following rules:
new_transpose(:([], wu31), ba) → new_transpose(wu31, ba)
new_transpose(:(:(wu300, wu301), wu31), ba) → new_transpose(:(wu301, new_foldr1(wu31, ba)), ba)
The TRS R consists of the following rules:
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_psPs(wu4, ba) → wu4
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_foldr2(ba) → []
The set Q consists of the following terms:
new_foldr1([], x0)
new_psPs1([], x0, x1)
new_foldr2(x0)
new_psPs0(x0, x1, x2)
new_psPs(x0, x1)
new_psPs1(:(x0, x1), x2, x3)
new_foldr1(:(x0, x1), x2)
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].
The following pairs can be oriented strictly and are deleted.
new_transpose(:([], wu31), ba) → new_transpose(wu31, ba)
new_transpose(:(:(wu300, wu301), wu31), ba) → new_transpose(:(wu301, new_foldr1(wu31, ba)), ba)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [25]:
POL(:(x1, x2)) = 1 + x1 + x2
POL([]) = 0
POL(app(x1, x2)) = 0
POL(new_foldr1(x1, x2)) = x1
POL(new_foldr2(x1)) = 0
POL(new_psPs(x1, x2)) = x1
POL(new_psPs0(x1, x2, x3)) = 1 + x1 + x2
POL(new_psPs1(x1, x2, x3)) = 1 + x1 + x2
POL(new_transpose(x1, x2)) = x1
POL(ty_[]) = 0
The following usable rules [17] were oriented:
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr2(ba) → []
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_psPs(wu4, ba) → wu4
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
↳ HASKELL
↳ Narrow
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ PisEmptyProof
↳ QDPOrderProof
Q DP problem:
P is empty.
The TRS R consists of the following rules:
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_psPs(wu4, ba) → wu4
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_foldr2(ba) → []
The set Q consists of the following terms:
new_foldr1([], x0)
new_psPs1([], x0, x1)
new_foldr2(x0)
new_psPs0(x0, x1, x2)
new_psPs(x0, x1)
new_psPs1(:(x0, x1), x2, x3)
new_foldr1(:(x0, x1), x2)
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
We use the reduction pair processor [15].
The following pairs can be oriented strictly and are deleted.
new_transpose(:([], wu31), ba) → new_transpose(wu31, ba)
new_transpose(:(:(wu300, wu301), wu31), ba) → new_transpose(:(wu301, new_foldr1(wu31, ba)), ba)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( new_foldr1(x1, x2) ) = | | + | | · | x1 | + | | · | x2 |
M( new_foldr2(x1) ) = | | + | | · | x1 |
M( app(x1, x2) ) = | | + | | · | x1 | + | | · | x2 |
M( new_psPs1(x1, ..., x3) ) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 |
M( new_psPs(x1, x2) ) = | | + | | · | x1 | + | | · | x2 |
M( new_psPs0(x1, ..., x3) ) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 |
M( :(x1, x2) ) = | | + | | · | x1 | + | | · | x2 |
Tuple symbols:
M( new_transpose(x1, x2) ) = | 0 | + | | · | x1 | + | | · | x2 |
Matrix type:
We used a basic matrix type which is not further parametrizeable.
As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr2(ba) → []
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_psPs(wu4, ba) → wu4
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
↳ HASKELL
↳ LR
↳ HASKELL
↳ CR
↳ HASKELL
↳ BR
↳ HASKELL
↳ COR
↳ HASKELL
↳ Narrow
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDPOrderProof
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_psPs(wu4, ba) → wu4
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_foldr2(ba) → []
The set Q consists of the following terms:
new_foldr1([], x0)
new_psPs1([], x0, x1)
new_foldr2(x0)
new_psPs0(x0, x1, x2)
new_psPs(x0, x1)
new_psPs1(:(x0, x1), x2, x3)
new_foldr1(:(x0, x1), x2)
We have to consider all minimal (P,Q,R)-chains.